
# addition
1 + 2


# exponents
20^(1/2)


# basic math functions
sqrt(20)


# advanced math functions
factorial(3)


# access to constants
pi

# This is a function to calculate the powers of e
exp(1)


# Plot a quick equation!
curve(10*x^2, from=0, to=2)


# Plot a parabola
curve(10*x^2, xlim = c(-2,2))


# Use ? to retrieve a description of help()
?help()
# Note the lack of ()?


help(help)


# A list of common functions that we won't look at
...

# ?c
# ?seq
# ?setwd
# ?sort
# ?dir
# ?head
# ?names
# ?summary
# ?dim
# ?range
# ?max
# ?min
# ?sum
# ?pairs
# ?plot


# Assign with the standard =

...

# Use the print command to print simple and complex expressions
print(a)

# Or just evaluate the expression to standard output
...


#Left hand assigner (original way to assign results) 
# sometimes the <- is necessary for functions originally created in S. 
# Often seen on R help forums if you Google future issues

a ... 3 
a


#Right hand assigner

3 ... d 
d


# Assign some variables
a = 4
b = 2

# Multiply them
...


# each code after a semicolon is interpreted as a line
a=4 ... b=2 ... a*b


b=2

a=3;b*a

#Vs

a = 3; ...


# No spaces
paste("Can", "I", "go", "out", "now", "?", ...)

# Single space as a separator
...

# Triple space as a separator
...


# What will be the final value of i?

i = 1
i = ...
i


# Use multiple values in an expression assigned to a variable 
result <- ... 
result

# make a calculation
result ^ pi


# Use and overwrite the current value of "result"
result <- ...

# this PERMANENTLY overwrote your old 'result' object. Remember not to SCREW yourself
result


# Don't forget that variable names ARE case-sensitive
a = 5
A = 7
b = 3
B = 15

# Output our variable values
b; B; ...


# It doesn't matter what your variable is named, a scalar is still a single value
X <- 5
b <- ...


# character vectors
character_vector <- c(...)
character_vector


# numeric vectors
numeric_vector <- c(...)
numeric_vector


# logical vectors
logical_vector <- c(...) # TRUE and FALSE are also know as "boolean"
logical_vector


# Integer vectors
integer_vector <- c(...) 
# The "L" makes the numbers integers. Can be used to get your code to run faster and consume less memory. 
# A double ("numeric") vector uses 8 bytes per element. An integer vector uses only 4 bytes per element

integer_vector


# What happens if we try to include more than one type of data?
mixed_vector <- c(...)
mixed_vector

# Let's look at the structure of our vector
str(mixed_vector)


# Let's convert our mixed_vector
...; into_numeric

# What about our logical_vector?
as.numeric(...)


names(logical_vector) <- c(...)
logical_vector


#is equivalent to 

logical_vector <- c("male" = TRUE, "elderly" = FALSE, "heart attack" = ...)

logical_vector


# or using a ;

logical_vector <- c("male" = TRUE, "elderly" = FALSE, "heart attack" = TRUE)... logical_vector


# The number of elements in a vector is its length.
length(character_vector)

length(numeric_vector)

length(...)


# Display our character vector again
character_vector

# You can grab a specific element by its index
character_vector[...]


# Use the ":" to generate a range of indices automatically as a vector
...

#second and third element in the vector inclusive (varies across programming languages)
character_vector[...]


#you can use negative indexing to select 'everything but'
character_vector[...]

character_vector[...]


# You can grab elements by their assigned "names"
logical_vector[...]

logical_vector[...]


# What will the output be?
my_matrix <- matrix(c(...), nrow = ..., ncol = ...)

my_matrix


# Equivalent result by calling rep just once

my_matrix <- matrix(c(rep(...)), nrow = 5, ncol = 5)

my_matrix


# Make a matrix by recycling within rep() but not within the matrix() call
my_matrix <- matrix(c(rep(...)), nrow = 5, ncol = 5)
my_matrix; print("version 1")


# No recycling in generating the initial vector
my_matrix <- matrix(c(rep(0, 10), rep(1,10), rep(0, 5)), nrow = 5, ncol = 5)
my_matrix; print("version 2")


# Just write out the entire vector you want to convert to matrix
my_matrix <- matrix(c(0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0), nrow = 5, ncol = 5)
my_matrix; print("version 3")


# We can replicate through coercion!
my_matrix <- matrix(as.numeric(c(rep(FALSE, 10), rep(TRUE,10), rep(FALSE, 5))), nrow = 5, ncol = 5)
my_matrix; print("version 4")


#This may be a good time to mention that TRUE and FALSE can be abbreviated to T and F
my_matrix <- matrix(as.numeric(c(F,F,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,T,T,F,F,F,F,F)), nrow = 5, ncol = 5)
my_matrix; print("version 5")


matrix(c(0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0), nrow = 5, ncol = 5)


...(c(rep(0, 10), rep(1,10), nrow = 5, ncol = 5))


# Define a matrix using a few different seq() calls
matrix(c(seq(...), 
         seq(3,12,3),                    # Note we don't have to name the parameters 
         rep(seq(0,1,1), 3)),            # This last call is a bit repetetive
       nrow = 4, ncol = 4, byrow = TRUE) # Notice also we are filling by row instead of by column


# Compare that to this version
matrix(c(seq(from = 2, to = 12, by = 2), 
         seq(3,12,3), 
         rep(..., 3)), # simplified 
       nrow = 4, ncol = 4, byrow = TRUE)


# Or hard-code that last section instead
matrix(c(seq(2, 12, 2), seq(3,12,3), ...), nrow = 4, ncol = 4, byrow = TRUE)


# Replace your 1s and 0s with booleans for coercion
matrix(c(seq(2, 12, 2), seq(3,12,3), rep(c(F,T), 3)), nrow = 4, ncol = 4, byrow = TRUE)


# A matrix is a 2D object. We can now check out a couple more properties - like the number of rows and columns.
my_matrix

print("structure")
...

print("rows")
...(my_matrix)

print("columns")
...(my_matrix)

print("dimensions")
...(my_matrix) # reported as rows vs columns

print("length")
...(my_matrix)


#To access a specific row or column we can still use indexing.

# Return rows 3:5 and all columns
my_matrix[...,]

# Return all rows, and column 4
my_matrix[, ...]


# How can we ask the type of object returned? 
...(my_matrix[,4])

# Look at the dimensions returned for a vector
str(my_matrix[,4])

# vs. a matrix
str(my_matrix[...])


# It is common to transform matrices. Note that the set of ones will now be in rows rather than columns.

...


class(character_vector)
class(numeric_vector)
class(...)


# Let's make a data frame
# Recall that we can generate a vector simply using c(data1, data2, ..., dataN)

my_data_frame <- data.frame(character = c(...),
                            num = c(...),
                            log = c(TRUE, FALSE, TRUE))

## Oops! This will break the second rule of data frame club


# Let's make a data frame correctly

my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(...),
                            log = c(TRUE, FALSE, TRUE))

my_data_frame


# What is the structure of a data frame?
...


# cast a matrix to a dataframe
new_data_frame <- ...(my_matrix)
new_data_frame


# Note that R just made up column names for us. We can provide our own vector of column names.
... <- c("col1", "col2", "col3", "col4", "col5")

#equivalent to
... <- c(paste0(rep("col",5), 1:5))
new_data_frame


# Rename our columns using specific positions
colnames(new_data_frame)[...] = c("newcol1", "newcol3", "newcol5")

# Let's check our handiwork
new_data_frame


# In contrast, our data frame with multiple data types cannot be converted into a matrix, as a matrix can only hold one data type. We could however, transform our new_data_frame back into a matrix. The matrix will retain our column heading.
new_matrix <- ...(my_data_frame)
str(new_matrix)
new_matrix


# Let's look at the "num" column closer
str(new_matrix[,...])


my_array <- array(data = ..., dim = c(...))

# Note that we need to print the array in order to make it more human-readable in Jupyter notebooks
print(my_array)

# What are the properties of my_array?
print("structure")
str(my_array)

print("dimensions")
dim(my_array)


# You can make matrices with characters too!
# This is a constant in R for upper case letters
LETTERS

print(array(data = ..., dim=c(3,4,2)))


# This arrangement makes it more clear how we would subset the number 7 out of array 5.
my_array[...]


# A 2D array is just a matrix. Unless you specify a 3rd dimension.

twoD_array <- array(data = 1:10, dim = c(...))
print(twoD_array)


#equivalent to

twoD_array2 <- array(data = 1:10, dim = c(...))
print(twoD_array)


# Check the difference between these two arrays
all.equal(...)
class(twoD_array)
class(twoD_array2)


mixed_list <- ...(character = c('bacteria', 'virus', 'archaea'), 
                   num = c(1:3), 
                   log = c(TRUE, FALSE, TRUE))

print(mixed_list)


#formatting - equivalent, but less reader friendly for longer lists
mixed_list = list(character = c('bacteria', 'virus', 'archaea'), num = c(1:10), log = c(TRUE, FALSE, TRUE))

print(mixed_list)


str(mixed_list)

str(...)


# To subset for 'virus', I first have to subset for the character element of the list. Kind of like a Russian nested doll or a present, where you have to open the outer layer to get to the next.

# Retrieve a single element directly
print("Retrieve a single element")
mixed_list...

# What kind of object is that?
print("What kind of object is it?")
str(mixed_list[[1]])

# Compare to using single []
print("Contrast to using the [] notation")
str(mixed_list[1])

# Access using a named element
print("What is returned using an elements name?")
str(mixed_list$...)


# Begin with [[]] notation and THEN index [] with the appropriate syntax 
mixed_list[[1]]...
mixed_list$character[2]

# This will fail because it returns a list!
mixed_list[1][2]


crazy_factor = ...(c("up", "down", "down", "sideways", "up"))

crazy_factor


# or
print(crazy_factor) 
# print() is needed inside iterative functions (e.g. looping) to actually print the ouput that is being generated


# Access levels of a factor directly with level()
...(crazy_factor)

# Is it a vector?
is.vector(levels(crazy_factor))


# Cast that factor
...(crazy_factor) 

#Notice the alphabetic rearrangement! It's important to keep this in mind when looping (week 7)


# Look at the data frame with and without the stringsAsFactors call
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

...(my_data_frame)


# All character vectors become factors
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE), ...)

str(my_data_frame)


# Only columns you specify as factors will be factors
my_data_frame <- data.frame(character = ...(c('bacteria', 'virus', 'archaea')),
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

str(my_data_frame)


my_data_frame$...

#equivalent to

my_data_frame...

levels(my_data_frame$character)


# Convert our factors to a numeric representation
...(my_data_frame$character)


# Set up my_data_frame again
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

#this is okay - specify your levels explicitly rather than allowing it to choose by default
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('bacteria', 'virus', 'archaea'))

# Note that you could define your factor inside the data.frame()

str(my_data_frame)
#archaea, bacteria, virus
#2,3,1


# Here's an example of misspelling levels. What will happen?
factor(c("bacteria", "virus", "archaea"), levels=c("bacteria", "virus", ...))


# Set up my_data_frame again
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

#this is okay, what we wanted except implies a < relationship
#class is actually 'ordered' 'factor'
#Ordered factors differ from factors only in their class, 
#but methods and the model-fitting functions treat the two classes quite differently.
my_data_frame$character <- factor(my_data_frame$character, 
                                  levels = c('bacteria', 'virus', 'archaea'), 
                                  ... = TRUE)

print(my_data_frame$character)
str(my_data_frame)
#bacteria, virus, archaea
#1,2,3


# When labeling factors can go wrong
# Run again my_data_frame
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

#factor() will decide the level order on it's OWN before applying the given labels!
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('label_1', 'label_2', '...'))

print(my_data_frame$character)
str(my_data_frame)
#bacteria, virus, archaea
#BUT named levels above, therefore
#bacteria = label_2, virus = label_3, archaea = label_1
#2,3,1
#BUT data frame changed to:
#virus, archaea, bacteria


# Labeling factors correctly
# Run again my_data_frame
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

# You need to supply factor() with the levels and labels if you want them turn our how you envision it
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('bacteria', 'virus', 'archaea'), # explicitly order your levels!
                                  ... = c('bacteria_label', 'virus_label', 'archaea_label')) # names the levels

#bacteria, virus, archaea
#1,2,3
print(my_data_frame$character)
str(my_data_frame)


my_data_frame

# or outside of Jupyter use the View() function for a pop-up pane that looks a bit like an excel sheet 
# (more familiar to our eyes)

print(my_data_frame)


# Multiply the entire data frame
my_data_frame ...

# Multiple just a single column
my_data_frame... * 4

# Slice a column and multiply
my_data_frame... * 4


# So you can do math... on an array.
print("my_array")
print(my_array)

print("Multiply all elements by 4")
print(my_array * 4)

print("Multiple a single element by 4")
print(my_array[...] * 4) # why do we have three indices for this array?


# Make a dataframe with 3 columns (Site1, Site2, Site3) and 4 rows (geneA, geneB, geneC, geneD)
counts <- data.frame(Site1 = c(geneA = 2, geneB = 4, geneC = 12, geneD = 8),
                     Site2 = c(geneA = 15, geneB = 18, geneC = 27, geneD = 28),
                     Site3 = c(geneA = 10, geneB = 7, geneC = 13, geneD = 15))
                     
counts

#?apply

# This won't work because x is lower case
#apply(x = counts, MARGIN = 1, FUN = sum)
print("apply() with sum across rows")
apply(X = counts, MARGIN = 1, FUN = ...)

print("apply() returns a numeric vector")
str(...)

class(...)


# Using apply() across rows
apply(counts, MARGIN = 1, mean)

apply(counts, MARGIN = 1, sd)

apply(counts, MARGIN = 1, median)

apply(counts, MARGIN = 1, ...)


apply(counts, MARGIN = 1, sum)

#equivalent to

apply(counts, MARGIN = 1, ...)


apply(counts, 
      MARGIN = 1, 
      function(x) (...))


# Set up some vectors for an array
brand <- c("wildrose", "guinness", "grasshoper")
wheat.type <- c("Hard Red Spring", "Hard Red Winter", "Soft Red Winter" )
rating <- c(...)

# Put it all together with cbind (you can use this for data frames too!)
NA.example <- cbind(brand, wheat.type, rating)

# Look at our matrix/array
NA.example


# Use the mean() function and see what happens with NA values
mean(rating) # some functions need to be explicitly told what to do with NAs. No errors though!

mean(rating, ...) #Avoid using just "T" as an abbreviation for "TRUE"


counts <- data.frame(Site1 = c(geneA = 2, geneB = 4, geneC = 12, geneD = 8),
                     Site2 = c(geneA = 15, geneB = NA, geneC = 27, geneD = 28),
                     Site3 = c(geneA = 10, geneB = 7, geneC = 13, geneD = NA))

counts

# Notice that we can only pass the function name "mean" and not any parameters
apply(counts, MARGIN = 1, ...)


# Pass parameters in our call
apply(counts, MARGIN = 1, mean, ...)

# Equivalent code - perhaps clearer but more verbose
apply(counts, MARGIN = 1, FUN = function(x) mean(x, na.rm=TRUE))


# Let's check out this vector that contains NA values
na_vector <- c(5, 6, NA, 7, 7, NA)

# This works on vectors...
...(na_vector)

# and data frames too!
...(counts)


# Take a look at na_vector before you start manipulating it
na_vector 

# wrap which() around our is.na() call
...(is.na(na_vector))

# indices where NAs are present in na_vector
na_values <- which(is.na(na_vector)) 

# cut out the na_values indices
removed_na_vector_1 <- na_vector[...] ; removed_na_vector_1


#equivalent to 
removed_na_vector_2 <- na_vector[!is.na(na_vector)] ; removed_na_vector_2


# equivalentish to our previous code
na.omit(...)


# But really it's doing something slightly different under the hood re data frames
na.omit(counts)


# Apply the log function to non-NA observations. In this case na.omit can be useful. 
#?na.omit
apply(counts, MARGIN = 1, na.omit(log))

# Read more about apply() to learn more about why our data frame is now transpose


# Let's see what is.na() returns
counts

is.na(counts) # logical (TRUE or FALSE). Where in the data frames are the NAs if any?


# Let's combine it with the any() function
?any
...(is.na(counts)) # "Given a set of logical vectors, is at least one of the values true?" 
# In our case, are there NAs at all in counts?


?complete.cases

# Outputs a logical vector specifying which observations/rows have no missing values across the entire sequence.
...(counts) 

# Use it wisely to grab rows. Pop quiz [x,y] will it be x or y?
counts[...]


na_vector <- c(5, 6, NA, 7, 7, NA)
nan_vector <- c(5, 6, NaN, 7, 7, ...)

is.na(na_vector)
is.na(nan_vector)

...(na_vector)
...(nan_vector) 

# These type of operations are very useful when working with conditional statements (if else, while, etc.).


# Find the NA values and just replace them with an equivalent value that makes sense to your analysis
counts[...] <- 0 

counts


# install.packages('devtools') # Always keep installation commands commented out


# install.packages('devtools', dependencies = TRUE)

# remove.packages("devtools") # Uninstall any CRAN package


library(...) 

# or 

#library('devtools')


if (!requireNamespace("BiocManager", quietly = TRUE)) 
    install.packages("BiocManager") # this piece of code checks if BiocManager is installed. If is not installed, it will do it for you. It does nothing if BiocManager is already installed.

BiocManager::install("...")

#or 

BiocManager::install(c("GenomicRanges", "ConnectivityMap"))


devtools::install_github("...")


# Load googlesheets4 now from the library
library(...)


install.packages('tidyverse', ...)

#didn't have to have 'dependencies = TRUE', but may have run into some issues

BiocManager::install("limma")


library(MASS)
data()


...(iris) # what do the first few rows look like?

str(iris) # what is the overall structure of this data set?

class(iris) # what is the class of this data set?

head(is.na(iris)) # Are there any NA values?

which(is.na(iris)) # Remember what this does?

iris[is.na(iris)] # What do you think we'll get back?


# Before writing, take a look your working directory.
getwd()
list.files() # check existing files in your current directory.
?write.csv

write.csv(..., 
          file = "iris_data set.csv", 
          row.names = FALSE, 
          quote = FALSE)

list.files()


# Write to an absolute location on your directory
write.csv(iris, 
          file = "...", 
          row.names = FALSE, 
          quote = FALSE)


getwd()

list.files()

?read.csv

iris_dataset <- read.csv("...", 
                        check.names = FALSE, stringsAsFactors = FALSE, 
                        header = TRUE, sep = ",", fill = TRUE)

str(iris_dataset) # check the structure
class(iris_dataset) # check the class


# Let's investigate the file we just read in.
# Read from the beginning of your table
head(iris_dataset, 7)

# Read from the end of your table
...(iris_dataset, 3)


#A brief on exploratory data analysis

# Recall our 5th column is just a species type
boxplot(iris_dataset[, 1:4]) 

# We can subset our data before plotting!
boxplot(iris_dataset[..., 1:4])


# Plot single variables like petal width
plot(iris_dataset$...)

# Or petal length
qqnorm(iris_dataset$Sepal.Length)
qqline(iris_dataset$Sepal.Length, col = 2) # Does iris' data come from a normally distributed population?

Data type	Description	Example
character	Can be single or multiple characters (strings) of letters and symbols. Assigned using double `'` or `"`	a#c&E
integer	Whole number values, either positive or negative	1
double	Any number that is not an integer	7.5
logical	Also known as a boolean, representing the state of a conditional (question)	TRUE or FALSE
NA	Represents the value of "Not Available" usually seen when imported data has missing values	NA

Data structure	Dimensions	Restrictions
vector	1D	Holds a single data type
matrix	2D	Holds a single data type
array	nD	Holds a single data type
data frame	2D	Holds multiple data types with some restrictions
list	1D (technically)	Holds multiple data types AND structures

Lecture 01: Basics of R and Jupyter Notebooks¶

0.1.0 About Introduction to R¶

0.1.1 Where is this course headed?¶

0.1.2 How do we get there? Step-by-step.¶

0.2.0 Class Objectives¶

0.3.0 A legend for text format in Jupyter markdown¶

0.4.0 Lecture and data files used in this course¶

0.4.1 Weekly Lecture and skeleton files¶

0.4.2 Live-coding HTML page¶

0.4.3 Post-lecture PDFs and Recordings¶

1.0.0 What is R?¶

1.0.1 Why learn R?¶

1.1.0 Jupyter Notebooks and the R-kernel¶

1.1.1 Why is this class using Jupyter Notebooks?¶

1.2.0 A quick intro to the R environment¶

1.2.1 Packages contain useful functions¶

1.2.2 Useful packages are archived with CRAN and Bioconductor¶

1.3.0 Jupyter notebooks run programming language kernels like R¶

1.3.1 Why would you want to use a Jupyter Notebook?¶

1.4.0 RStudio is an integrated development environment (IDE) for R¶

1.4.1 Why would you want to use R and RStudio?¶

1.5.0 What should I use?¶

1.6.0 Making Life Easier¶

1.6.1 Annotate your code with #¶

1.6.2 Naming conventions for files, objects, and functions¶

1.6.3 Best Practices for Writing Scripts¶

1.7.0 Trouble-shooting basics¶

1.7.1 Common errors¶

1.7.2 Beginner Advice¶

1.7.3 Finding answers online¶

1.7.3.1 Asking a question¶

2.0.0 Using R¶

2.1.0 Basic use of R¶

2.1.1 Basic math and functions¶

2.1.2 Plot equations¶

2.2.0 Functions do the work for us¶

2.2.1 Use the help() function or ? to learn more about functions¶

3.0.0 A [quick] intro to R's variables, data types, and data structures¶

3.1.0 Assigning variables¶

3.1.1 Blank spaces are usually ignored by the interpreter¶

3.1.1.1 A special case where blankspace matters¶

3.1.2 R calculates from the right side first before (leftward) assignment¶

3.2.0 Data types are the basic building blocks of R¶

3.2.1 Data structures hold single or multiple values¶

3.2.2 Scalars - "One is the loneliest data type"¶

3.2.3 Vectors are like a queue of a single data type¶

3.2.3.1 Coercion changes data from one type to another (if possible)¶

3.2.3.2 What happened to our data??¶

3.2.3.3 Vector contents can be individually named using the name() function¶

3.2.3.4 Use length() to identify the number of elements in a vector¶

3.2.3.5 Use the [ ] indexing notation to extract values¶

3.2.4 Matrices are 2-dimensional containers of a single data type¶

3.2.4.1 A reminder about functions inside functions¶

3.2.4.2 Bracket and parentheses location matters!¶

3.2.4.3 Challenge¶

3.2.4.4 A matrix is a 2D object¶

3.2.4.5 Use [row, column] notation to access portions of a matrix¶

3.2.4.6 Subsetting a matrix returns a vector or matrix¶

3.2.5 Data Frames¶

3.2.5.1 Object classes¶

3.2.5.2 Data frames are groups of vectors disguised as matrices¶

3.2.5.3 Casting a matrix to a data frame using as.data.frame()¶

3.2.5.4 You can access and rename data frame columns (like a header!) with colnames()¶

3.2.5.5 You can't always cast a data frame to a matrix as expected¶

3.2.5.6 Some useful data frame commands (for now)¶

3.2.6 Arrays¶

3.2.6.1 Access elements from an array¶

3.2.7 Lists are amorphous bundles strung together with code¶

3.2.7.1 Lists can get complicated.¶

3.2.7.2 Accessing elements from a list with [[ ]] and [ ]¶

3.2.7.3 Use additional levels of [ ] notation to access sub-elements of a list¶

3.2.8 Factors represent categorical data¶

3.2.8.1 Use levels() to access factors information¶

3.2.8.2 Coerce you factor to an integer with as.integer()¶

3.2.8.3 A brief note about R 4.0.x versus r 3.x.x¶

3.2.8.4 The default behaviour of data.frame() creation does not make factors¶

3.2.8.5 Specify factors during data frame creation with stringsAsFactors or as.factor()¶

3.2.8.6 Factor levels are ordered alphabetically by default¶

3.2.8.7 You can specify the order of your factor levels using the levels parameter¶

3.2.8.8 You can specify an order of precedence in your factor levels¶

1.6.1 Annotate your code with `#`¶

2.2.1 Use the `help()` function or `?` to learn more about functions¶

3.2.3.3 Vector contents can be individually named using the `name()` function¶

3.2.3.4 Use `length()` to identify the number of elements in a vector¶

3.2.3.5 Use the `[ ]` indexing notation to extract values¶

3.2.4.5 Use `[row, column]` notation to access portions of a matrix¶

3.2.5.3 Casting a matrix to a data frame using `as.data.frame()`¶

3.2.5.4 You can access and rename data frame columns (like a header!) with `colnames()`¶

3.2.7.2 Accessing elements from a list with `[[ ]]` and `[ ]`¶

3.2.7.3 Use additional levels of `[ ]` notation to access sub-elements of a list¶

3.2.8.1 Use `levels()` to access factors information¶

3.2.8.2 Coerce you factor to an integer with `as.integer()`¶

3.2.8.4 The default behaviour of `data.frame()` creation does not make factors¶

3.2.8.5 Specify factors during data frame creation with `stringsAsFactors` or `as.factor()`¶

3.2.8.7 You can specify the order of your factor levels using the `levels` parameter¶

3.2.8.9 You can relabel your factor values with the `labels` parameter but be careful!¶

3.2.8.10 The `factor()` function applies a default `level` behaviour before applying the `labels` parameter¶

3.3.1 Using the `apply()` function to perform actions across data structures¶

3.3.1.1 The `apply()` function will recognize basic functions.¶

3.3.1.2 Supply a custom function to `apply()`¶

3.3.2 Special data: `NA` and `NaN` values¶

3.3.2.1 Some functions can be told to ignore or remove `NA` values¶

3.3.2.2 What happens when we try to use functions via `apply()` on data with NAs?¶

3.3.2.3 Use the `is.na()` function to check your data¶

3.3.2.4 Find what you're looking for with the `which()` function¶

3.3.2.5 The `na.omit()` function will remove `NA` entries¶

3.3.2.6 The `any()` function evaluates logical vectors¶

3.3.2.7 Use `complete.cases()` to query larger objects¶

3.3.2.9 Consider just replacing the `NA`s with something useful¶

4.2.2 Use `library()` to load your packages after installation¶

4.2.2.1 Use `lapply()` to load several libraries simultaneously using a vector of package names¶

4.2.2.2 Loading packages from bioconductor requires `BiocManager()`¶

4.2.2.3 Skip loading a library with `package::function()`¶